<?php

class WfWorkflow {
//<editor-fold defaultstate="collapsed" desc="Constantes">
  const NOMBRE_ENTIDAD = "WfWorkflow";
  const SESION_LISTADO = "WfWorkflowListado";
//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="Campos">
  private $_id;
  private $_nombre;
  private $_descripcion;
  private $_activo;
  private $_idEmpresa;
  private $_idPlantilla;
  private $_idUltimoCache;
  private $_valorPlazoTotal;
  private $_unidadMedidaPlazoTotal;
  private $_fechaInicio;
  private $_fechaTermino;
  private $_puedeMoverPasos;
  private $_eliminado;
  private $_existe;
//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="Propiedades">
  public function getId() { return $this->_id; }
  public function setId($value) { $this->_id = $value; }

  public function getNombre() { return $this->_nombre; }
  public function setNombre($value) { $this->_nombre = $value; }

  public function getDescripcion() { return $this->_descripcion; }
  public function setDescripcion($value) { $this->_descripcion = $value; }

  public function getActivo() { return $this->_activo; }
  public function setActivo($value) { $this->_activo = $value; }

  public function getIdEmpresa() { return $this->_idEmpresa; }
  public function setIdEmpresa($value) { $this->_idEmpresa = $value; }

  public function getIdPlantilla() { return $this->_idPlantilla; }
  public function setIdPlantilla($value) { $this->_idPlantilla = $value; }

  public function getIdUltimoCache() { return $this->_idUltimoCache; }
  public function setIdUltimoCache($value) { $this->_idUltimoCache = $value; }

  public function getValorPlazoTotal() { return $this->_valorPlazoTotal; }
  public function setValorPlazoTotal($value) { $this->_valorPlazoTotal = $value; }

  public function getUnidadMedidaPlazoTotal() { return $this->_unidadMedidaPlazoTotal; }
  public function setUnidadMedidaPlazoTotal($value) { $this->_unidadMedidaPlazoTotal = $value; }

  public function getFechaInicio() { return $this->_fechaInicio; }
  public function setFechaInicio($value) { $this->_fechaInicio = $value; }

  public function getFechaTermino() { return $this->_fechaTermino; }
  public function setFechaTermino($value) { $this->_fechaTermino = $value; }

  public function getPuedeMoverPasos() { return $this->_puedeMoverPasos; }
  public function setPuedeMoverPasos($value) { $this->_puedeMoverPasos = $value; }

  public function getEliminado() { return $this->_eliminado; }
  public function setEliminado($value) { $this->_eliminado = $value; }

  public function getExiste() { return $this->_existe; }
  public function setExiste($value) { $this->_existe = $value; }
//</editor-fold>
  
//<editor-fold defaultstate="collapsed" desc="Metodos Publicos">
  /**
   * constructor
   * @author VSR, 06/06/2012
   */
  public function __construct() {
    try {
        $this->_id = -1;
        $this->_nombre = "";
        $this->_descripcion = "";
        $this->_activo = 0;
        $this->_idEmpresa = -1;
        $this->_idPlantilla = -1;
        $this->_idUltimoCache = -1;
        $this->_valorPlazoTotal = 0;
        $this->_unidadMedidaPlazoTotal = "";
        $this->_fechaInicio = "";
        $this->_fechaTermino = "";
        $this->_puedeMoverPasos = 0;
        $this->_eliminado = 0;
        $this->_existe = 0;
    } catch (Exception $e) {
      throw new Exception($e->getMessage());
    }
  }

  /**
   * obtiene registro por su id
   * @author VSR, 06/06/2012
   */
  public function obtenerPorId($id = -1) {
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_ObtenerPorId({id});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{id}", $id, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
      $totalRegistros = count($arr);

      //si se encontraron registros entonces se asignan
      if ($totalRegistros > 0) {
        $row = $arr[0];
        $this->_id = ( is_null($row["Id"]) ) ? -1 : $row["Id"];
        $this->_nombre = ( is_null($row["Nombre"]) ) ? "" : $row["Nombre"];
        $this->_descripcion = ( is_null($row["Descripcion"]) ) ? "" : $row["Descripcion"];
        $this->_activo = ( is_null($row["Activo"]) ) ? 0 : $row["Activo"];
        $this->_idEmpresa = ( is_null($row["IdEmpresa"]) ) ? -1 : $row["IdEmpresa"];
        $this->_idPlantilla = ( is_null($row["IdPlantilla"]) ) ? -1 : $row["IdPlantilla"];
        $this->_idUltimoCache = ( is_null($row["IdUltimoCache"]) ) ? -1 : $row["IdUltimoCache"];
        $this->_valorPlazoTotal = ( is_null($row["ValorPlazoTotal"]) ) ? 0 : $row["ValorPlazoTotal"];
        $this->_unidadMedidaPlazoTotal = ( is_null($row["UnidadMedidaPlazoTotal"]) ) ? "" : $row["UnidadMedidaPlazoTotal"];
        $this->_fechaInicio = ( is_null($row["FechaInicio"]) ) ? "" : $row["FechaInicio"];
        $this->_fechaTermino = ( is_null($row["FechaTermino"]) ) ? "" : $row["FechaTermino"];
        $this->_puedeMoverPasos = ( is_null($row["PuedeMoverPasos"]) ) ? 0 : $row["PuedeMoverPasos"];
        $this->_eliminado = ( is_null($row["Eliminado"]) ) ? 0 : $row["Eliminado"];
        $this->_existe = ($this->_id == -1) ? 0 : 1;
      } else {
        $this->_id = -1;
        $this->_nombre = "";
        $this->_descripcion = "";
        $this->_activo = 0;
        $this->_idEmpresa = -1;
        $this->_idPlantilla = -1;
        $this->_idUltimoCache = -1;
        $this->_valorPlazoTotal = 0;
        $this->_unidadMedidaPlazoTotal = "";
        $this->_fechaInicio = "";
        $this->_fechaTermino = "";
        $this->_puedeMoverPasos = 0;
        $this->_eliminado = 0;
        $this->_existe = 0;
      }
    } catch (Exception $e) {
      throw new Exception($e->getMessage());
    }
  }

  /**
   * crea o actualiza un registro
   * @author VSR, 06/06/2012
   */
  public function grabar() {
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_Grabar({id},'{nombre}','{descripcion}',{activo},{idEmpresa},{idPlantilla},{idUltimoCache},{valorPlazoTotal},'{unidadMedidaPlazoTotal}','{fechaInicio}','{fechaTermino}',{puedeMoverPasos},{eliminado});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{id}", $this->_id, $sp);
      $sp = str_replace("{nombre}", $this->_nombre, $sp);
      $sp = str_replace("{descripcion}", $this->_descripcion, $sp);
      $sp = str_replace("{activo}", $this->_activo, $sp);
      $sp = str_replace("{idEmpresa}", $this->_idEmpresa, $sp);
      $sp = str_replace("{idPlantilla}", $this->_idPlantilla, $sp);
      $sp = str_replace("{idUltimoCache}", $this->_idUltimoCache, $sp);
      $sp = str_replace("{valorPlazoTotal}", $this->_valorPlazoTotal, $sp);
      $sp = str_replace("{unidadMedidaPlazoTotal}", $this->_unidadMedidaPlazoTotal, $sp);
      $sp = str_replace("{fechaInicio}", $this->_fechaInicio, $sp);
      $sp = str_replace("{fechaTermino}", $this->_fechaTermino, $sp);
      $sp = str_replace("{puedeMoverPasos}", $this->_puedeMoverPasos, $sp);
      $sp = str_replace("{eliminado}", $this->_eliminado, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
      $totalRegistros = count($arr);

      //si se encontraron registros entonces se asignan
      if ($totalRegistros > 0) {
        $row = $arr[0];
        $this->_id = $row["Id"];
        $this->_existe = 1;
      } else {
        $this->_id = -1;
        $this->_existe = 0;
      }
    } catch (Exception $e) {
      throw new Exception($e->getMessage());
    }
  }

  /**
   * elimina un registro
   * @author VSR, 06/06/2012
   */
  public function eliminar() {
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_Eliminar({id});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{id}", $this->_id, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
      $totalRegistros = count($arr);

      //si se encontraron registros entonces se asignan
      $this->_id = -1;
      $this->_existe = 0;
    } catch (Exception $e) {
      throw new Exception($e->getMessage());
    }
  }

  /**
   * destructor
   * @author VSR, 06/06/2012
   */
  public function  __destruct() {
   // destruye el objeto
  }
//</editor-fold>

//<editor-fold defaultstate="collapsed" desc="Metodos Compartidos">
  /**
   * obtiene listado de workflow
   * @param <type> $idUsuario
   * @param <type> $filtroNombre
   * @return string
   * @author VSR, 24/11/2011
   */
  public static function obtenerListadoConFiltro($idUsuario, $filtroNombre, $idEmpresa) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_ObtenerListadoConFiltro({idUsuario},'{filtroNombre}',{idEmpresa});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);
      $sp = str_replace("{filtroNombre}", $filtroNombre, $sp);
      $sp = str_replace("{idEmpresa}", $idEmpresa, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * obtiene el detalle del workflow
   * @param <type> $idWorkflow
   * @return string
   * @author VSR, 27/11/2011
   */
  public static function obtenerDetalle($idWorkflow) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_ObtenerDetalle({idWorkflow});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idWorkflow}", $idWorkflow, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp,Bd::MULTI_QUERY);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  
  public static function obtenerDetallePorIdEmpresa($idEmpresa) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_ObtenerDetallePorIdEmpresa({idEmpresa});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idEmpresa}", $idEmpresa, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * graba o actualiza los datos del workflow
   * @param <type> $idWorkflow
   * @param <type> $nombre
   * @param <type> $idEmpresa
   * @param <type> $idPlantilla
   * @param <type> $activo
   * @param <type> $listadoIdEncargados
   * @param <type> $observacion
   * @param <type> $idUsuario
   * @param <type> $listadoPermisosEncargados
   * @param <type> $valorPlazoTotal
   * @param <type> $unidadMedidaPlazoTotal
   * @param <type> $fechaInicio
   * @param <type> $fechaTermino
   * @param <type> $puedeMoverPasos
   * @return string
   * @author VSR, 27/11/2011
   */
  public static function grabarDatos($idWorkflow, $nombre, $idEmpresa, $idPlantilla, $activo, $listadoIdEncargados, $observacion,
                                     $idUsuario, $listadoPermisosEncargados, $valorPlazoTotal, $unidadMedidaPlazoTotal, $fechaInicio,
                                     $fechaTermino, $puedeMoverPasos) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_GrabarDatos({idWorkflow},'{nombre}',{idEmpresa},{idPlantilla},{activo},'{listadoIdEncargados}','{observacion}',{idUsuario},'{listadoPermisosEncargados}',{valorPlazoTotal},'{unidadMedidaPlazoTotal}','{fechaInicio}','{fechaTermino}',{puedeMoverPasos});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idWorkflow}", $idWorkflow, $sp);
      $sp = str_replace("{nombre}", $nombre, $sp);
      $sp = str_replace("{idEmpresa}", $idEmpresa, $sp);
      $sp = str_replace("{idPlantilla}", $idPlantilla, $sp);
      $sp = str_replace("{activo}", $activo, $sp);
      $sp = str_replace("{listadoIdEncargados}", $listadoIdEncargados, $sp);
      $sp = str_replace("{observacion}", $observacion, $sp);
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);
      $sp = str_replace("{listadoPermisosEncargados}", $listadoPermisosEncargados, $sp);
      $sp = str_replace("{valorPlazoTotal}", $valorPlazoTotal, $sp);
      $sp = str_replace("{unidadMedidaPlazoTotal}", $unidadMedidaPlazoTotal, $sp);
      $sp = str_replace("{fechaInicio}", $fechaInicio, $sp);
      $sp = str_replace("{fechaTermino}", $fechaTermino, $sp);
      $sp = str_replace("{puedeMoverPasos}", $puedeMoverPasos, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * obtiene listado de plantillas para mostrar en el combo
   * @param <type> $idEmpresa
   * @param <type> $idPlantillaSeleccionada
   * @return string
   * @author VSR, 27/11/2011
   */
  public static function obtenerComboPlantillaJSON($idEmpresa, $idPlantillaSeleccionada) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_ObtenerComboPlantillaJSON({idEmpresa},{idPlantillaSeleccionada});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idEmpresa}", $idEmpresa, $sp);
      $sp = str_replace("{idPlantillaSeleccionada}", $idPlantillaSeleccionada, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * obtiene los usuarios en formato JSON
   * @param <type> $idEmpresa
   * @return string
   * @author VSR, 28/11/2011
   */
  public static function obtenerUsuariosJSON($idEmpresa) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_ObtenerUsuariosJSON({idEmpresa});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idEmpresa}", $idEmpresa, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * obtiene los permisos del paso para configurarlo
   * @return string
   * @author VSR, 30/11/2011
   */
  public static function obtenerPermisosPasoJSON() {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_ObtenerPermisosPasoJSON();";

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * graba los datos del paso
   * @param <type> $idWorkflow
   * @param <type> $intPaso
   * @param <type> $strNombrePaso
   * @return <type>
   * @author VSR, 30/11/2011
   */
  public static function grabarPaso($idWorkflow, $intIdPaso, $strNombrePaso, $intOrdenPaso, $intValorPlazo, $strUnidadMedida, $strAprobadores, $srtPermisos,
                                    $intValorSemaforoAmarillo, $strUnidadMedidaSemaforoAmarillo) {
    $retorno = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_GrabarPaso({idWorkflow},{intIdPaso},'{strNombrePaso}',{intOrdenPaso},'{intValorPlazo}','{strUnidadMedida}', '{strAprobadores}', '{srtPermisos}','{intValorSemaforoAmarillo}','{strUnidadMedidaSemaforoAmarillo}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idWorkflow}", $idWorkflow, $sp);
      $sp = str_replace("{intIdPaso}", $intIdPaso, $sp);
      $sp = str_replace("{strNombrePaso}", $strNombrePaso, $sp);
      $sp = str_replace("{intOrdenPaso}", $intOrdenPaso, $sp);
      $sp = str_replace("{intValorPlazo}", $intValorPlazo, $sp);
      $sp = str_replace("{strUnidadMedida}", $strUnidadMedida, $sp);
      $sp = str_replace("{strAprobadores}", $strAprobadores, $sp);
      $sp = str_replace("{srtPermisos}", $srtPermisos, $sp);
      $sp = str_replace("{intValorSemaforoAmarillo}", $intValorSemaforoAmarillo, $sp);
      $sp = str_replace("{strUnidadMedidaSemaforoAmarillo}", $strUnidadMedidaSemaforoAmarillo, $sp);

      //ejecuta procedimiento
      $retorno = Bd::exec($sp, Bd::SCALAR);
    } catch (Exception $e) {
      $retorno = Sistema::CODIGO_SQL_ERROR;
    }
    return $retorno;
  }

  /**
   * obtiene los pasos del workflow
   * @param <type> $idWorkflow
   * @return string
   * @author VSR, 04/12/2011
   */
  public static function obtenerPasos($idWorkflow) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_ObtenerPasos({idWorkflow});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idWorkflow}", $idWorkflow, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp, Bd::MULTI_QUERY);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * elimina los pasos que no existen
   * @param <type> $idWorkflow
   * @param <type> $listadoIdPaso
   * @return <type> 
   * @author VSR, 04/12/2011
   */
  public static function eliminarPasosNoExistentes($idWorkflow, $listadoIdPaso) {
    $retorno = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_EliminarPasosNoExistentes({idWorkflow},'{listadoIdPaso}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idWorkflow}", $idWorkflow, $sp);
      $sp = str_replace("{listadoIdPaso}", $listadoIdPaso, $sp);

      //ejecuta procedimiento
      $retorno = Bd::exec($sp, Bd::SCALAR);
    } catch (Exception $e) {
      $retorno = Sistema::CODIGO_SQL_ERROR;
    }
    return $retorno;
  }

  /**
   * obtiene la estructura de los pasos actuales para determinar si cambiaron o no
   * @param <type> $idWorkflow
   * @return string 
   * @author VSR, 06/01/2012
   */
  public static function obtenerEstructuraPasosActuales($idWorkflow) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_ObtenerEstructuraPasosActuales({idWorkflow});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idWorkflow}", $idWorkflow, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp, Bd::MULTI_QUERY);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * graba el cache asociado al workflow
   * @param <type> $idWorkflow
   * @return <type> 
   * @author VSR, 07/01/2012
   */
  public static function grabarCache($idWorkflow) {
    $retorno = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_GrabarCache({idWorkflow});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idWorkflow}", $idWorkflow, $sp);

      //ejecuta procedimiento
      $retorno = Bd::exec($sp, Bd::SCALAR);
    } catch (Exception $e) {
      $retorno = Sistema::CODIGO_SQL_ERROR;
    }
    return $retorno;
  }

  /**
   * elimina el workflow y todas sus referencias
   * @param <type> $idWorkflow
   * @return <type>
   * @author VSR, 07/01/2012
   */
  public static function eliminarDatos($idWorkflow) {
    $retorno = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_EliminarDatos({idWorkflow});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idWorkflow}", $idWorkflow, $sp);

      //ejecuta procedimiento
      $retorno = Bd::exec($sp, Bd::SCALAR);
    } catch (Exception $e) {
      $retorno = Sistema::CODIGO_SQL_ERROR;
    }
    return $retorno;
  }

  /**
   * elimina los cache que no se utilizan
   * @return <type> 
   */
  public static function eliminarCacheNoReferenciados() {
    $retorno = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_EliminarCacheNoReferenciados();";

      //ejecuta procedimiento
      $retorno = Bd::exec($sp, Bd::SCALAR);
    } catch (Exception $e) {
      $retorno = Sistema::CODIGO_SQL_ERROR;
    }
    return $retorno;
  }

  /**
   * elimina el workflow logicamente
   * @param <type> $idWorkflow
   * @param <type> $idUsuario
   * @return <type>
   * @author VSR, 04/02/2012
   */
  public static function eliminacionLogica($idWorkflow, $idUsuario) {
    $retorno = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_EliminacionLogica({idWorkflow},{idUsuario});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idWorkflow}", $idWorkflow, $sp);
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);

      //ejecuta procedimiento
      $retorno = Bd::exec($sp, Bd::SCALAR);
    } catch (Exception $e) {
      $retorno = Sistema::CODIGO_SQL_ERROR;
    }
    return $retorno;
  }

  /**
   * obtiene listado de workflow por empresa
   * @param <type> $idEmpresa
   * @return string
   * @author VSR, 09/05/2012
   */
  public static function obtenerListadoPorEmpresa($idEmpresa) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_ObtenerListadoPorEmpresa({idEmpresa});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idEmpresa}", $idEmpresa, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }

  /**
   * elimina el listado de workflow logicamente
   * @param <type> $listadoId
   * @param <type> $idUsuario
   * @return <type>
   * @author VSR, 10/05/2012
   */
  public static function eliminacionLogicaListado($idEmpresa, $listadoId, $idUsuario) {
    $retorno = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_EliminacionLogicaListado({idEmpresa},'{listadoId}',{idUsuario});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idEmpresa}", $idEmpresa, $sp);
      $sp = str_replace("{listadoId}", $listadoId, $sp);
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);

      //ejecuta procedimiento
      $retorno = Bd::exec($sp, Bd::SCALAR);
    } catch (Exception $e) {
      $retorno = Sistema::CODIGO_SQL_ERROR;
    }
    return $retorno;
  }

  /**
   * graba los datos minimos del workflow
   * @param <type> $idWorkflow
   * @param <type> $idEmpresa
   * @param <type> $nombre
   * @param <type> $idPlantilla
   * @param <type> $activo
   * @param <type> $descripcion
   * @param <type> $fechaInicio
   * @param <type> $fechaTermino
   * @param <type> $idUsuario
   * @return <type>
   * @author VSR, 10/05/2012
   */
  public static function grabarDatosMinimos($idWorkflow, $idEmpresa, $nombre, $idPlantilla, $activo, $descripcion, $fechaInicio, $fechaTermino, $idUsuario) {
    $retorno = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_GrabarDatosMinimos({idWorkflow},{idEmpresa},'{nombre}',{idPlantilla},{activo},'{descripcion}','{fechaInicio}','{fechaTermino}',{idUsuario});";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idWorkflow}", $idWorkflow, $sp);
      $sp = str_replace("{idEmpresa}", $idEmpresa, $sp);
      $sp = str_replace("{nombre}", $nombre, $sp);
      $sp = str_replace("{idPlantilla}", $idPlantilla, $sp);
      $sp = str_replace("{activo}", $activo, $sp);
      $sp = str_replace("{descripcion}", $descripcion, $sp);
      $sp = str_replace("{fechaInicio}", $fechaInicio, $sp);
      $sp = str_replace("{fechaTermino}", $fechaTermino, $sp);
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);

      //ejecuta procedimiento
      $retorno = Bd::exec($sp, Bd::SCALAR);
    } catch (Exception $e) {
      $retorno = Sistema::CODIGO_SQL_ERROR;
    }
    return $retorno;
  }

  /**
   * obtiene las opciones del menu a mostrar
   * @param <type> $idUsuario
   * @param <type> $idEmpresa
   * @return string
   * @author VSR, 04/05/2012
   */
  public static function obtenerOpcionesMenu($idUsuario, $idEmpresa) {
    $arr = null;
    try {
      //define llamada procedimiento almacenado
      $sp = "CALL spu_WfWorkflow_ObtenerOpcionesMenu('{idUsuario}','{idEmpresa}');";

      //reemplaza marcas por valores reales
      $sp = str_replace("{idUsuario}", $idUsuario, $sp);
      $sp = str_replace("{idEmpresa}", $idEmpresa, $sp);

      //ejecuta procedimiento
      $arr = Bd::exec($sp, Bd::MULTI_QUERY);
    } catch (Exception $e) {
      $arr = null;
    }
    return $arr;
  }


//</editor-fold>
  
}
?>

